feat(md): Zig markdown parser with Bun.markdown API - #26440

In `@src/bun.js/api/MarkdownObject.zig`:
- Around line 121-160: Rename the module-private struct fields in
JsCallbackRenderer (and its nested Callbacks and StackEntry) to use a leading
'#' (e.g., globalObject -> `#globalObject`, allocator -> `#allocator`, src_text ->
`#src_text`, stack -> `#stack`, callbacks -> `#callbacks`, has_js_error ->
`#has_js_error`, and similar for all fields inside Callbacks and StackEntry) and
update all references/call sites to the new private names (search for usages of
JsCallbackRenderer, Callbacks, and StackEntry and replace field accesses
accordingly) so the structs follow the private field naming convention.
- Around line 196-275: appendToTop and the various stack.append calls currently
swallow allocation failures; change their catches to set an allocation error
flag (reuse or add a field like has_js_error or has_alloc_error on
JsCallbackRenderer) and return immediately instead of ignoring the error.
Specifically, replace the empty catches in appendToTop
(top.buffer.appendSlice(... ) catch {}) and the stack.append(...) calls in
enterBlockImpl and enterSpanImpl (and any other stack.append uses) with catches
that set self.has_js_error = true (or self.has_alloc_error = true) and return;
ensure render() (or the top-level caller) checks that flag and aborts/surfaces
an error when set so OOMs are not silently dropped.

In `@src/bundler/ParseTask.zig`:
- Around line 371-385: The markdown-to-HTML error should not be converted into
error.ParserError; change the catch on bun.md.renderToHtml in the .md arm to a
catch |err| block that logs the failure (using log.addError with the original
err context), calls bun.handleOom(err) to let OOMs be handled, and then returns
err to propagate the real error to the caller instead of returning
error.ParserError; update the code around bun.md.renderToHtml, the catch block,
and the surrounding control flow in ParseTask.zig so the original error is
returned.

In `@src/md/autolinks.zig`:
- Around line 145-251: The function findPermissiveAutolink reads content[pos]
without bounds checking; add an early guard at the top of findPermissiveAutolink
to return a not-found AutolinkResult when content is empty or pos is out of
range (e.g., if content.len == 0 or pos >= content.len) so external callers
cannot trigger an out-of-bounds access; update the initial checks in
findPermissiveAutolink (referencing pos and content) to return .{ .found =
false, .beg = 0, .end = 0 } when the guard fails.

In `@src/md/blocks.zig`:
- Around line 701-740: In endCurrentBlock, the call to
self.block_bytes.appendSlice(self.allocator, line_bytes) currently swallows
allocation failures; change it to propagate the error by checking the result of
appendSlice and returning the OutOfMemory error (or bubbling the specific error)
instead of ignoring it so callers of endCurrentBlock see allocation failures;
locate the appendSlice call in endCurrentBlock (uses self.current_block_lines
and line_bytes) and replace the catch {} with proper error handling that returns
the error from appendSlice.
- Around line 29-554: In analyzeLine, the paragraph-interrupt check uses "off >=
self.size" but then calls self.ch(cont_result.off) which accesses
cont_result.off; change the guard to check cont_result.off (i.e., use
cont_result.off >= self.size or helpers.isNewline(self.ch(cont_result.off)) as
appropriate) so the bounds check matches the actual index passed to self.ch;
update the conditional around the "Blank after list mark can't interrupt
paragraph" branch that currently references off to instead reference
cont_result.off to avoid out-of-range access when cont_result.off == self.size.

In `@src/md/containers.zig`:
- Around line 89-98: Update the misleading comment inside the
isContainerCompatible function: change the comment "Bullet lists: different
bullet chars are compatible" to accurately state that different bullet
characters are incompatible (e.g., "Bullet lists: different bullet chars are
incompatible"), so the comment matches the existing logic that returns false
when isListBullet(existing.ch) and isListBullet(new.ch); reference the
isContainerCompatible function and the isListBullet check to locate the line to
edit.

In `@src/md/helpers.zig`:
- Around line 80-175: Revert/remove the added Unicode-version comment and keep
the existing source attribution in the isUnicodePunctuationExtended function: do
not introduce a specific Unicode version note for the ranges; instead retain the
existing comment that they "match md4c's punct map" (referencing
isUnicodePunctuationExtended and its ranges array) so the code continues to
point maintainers to md4c as the authoritative source.

In `@src/md/inlines.zig`:
- Around line 576-581: The subtraction-assignment `closer_idx -%= 1` in the
while loop (used with `closer_idx` and `delims`) is a wrapping trick to undo the
loop's upcoming increment so the same closer gets re-checked; add a brief inline
comment next to that statement explaining that intent (mention `closer_idx`,
`delims[closer_idx].remaining` and `delims[closer_idx].can_close`) so future
readers understand this wrap-around subtraction is purposely undoing the loop
increment to re-process the same closer.

In `@src/md/line_analysis.zig`:
- Around line 19-21: The isHrLine function reads self.text[off] without
verifying the index is in range, mirroring the same bounds issue noted for
isSetextUnderline; add a guard to ensure off is within self.text.len (or use the
existing safe accessor) before accessing self.text[off], returning false if
out-of-bounds, and apply the same pattern used in isSetextUnderline so isHrLine
(and any similar functions) do not perform unchecked indexing.
- Around line 311-374: The function isTableUnderline mutates parser state
(self.table_alignments and self.table_col_count) despite an `is*` name that
implies a pure predicate; either rename the function to reflect side effects
(e.g., parseTableUnderline or consumeTableUnderline) or explicitly document that
it updates parser state, and update all call sites and tests to use the new name
or expect the side effects; specifically change references to isTableUnderline,
and ensure the behavior around self.table_alignments (the alignment assignments)
and self.table_col_count (final assignment) is preserved when renaming or adding
documentation.
- Around line 1-3: The function isSetextUnderline currently accesses
self.text[off] without ensuring off < self.size; add a defensive bounds check at
the start of isSetextUnderline to verify off is within range (e.g., if (off >=
self.size) return .{ .is_setext = false, .level = 0 } ) or alternatively assert
the precondition with a clear message; ensure you reference the same symbols
(isSetextUnderline, self.text, self.size, off) so the guard prevents
out-of-bounds reads before the existing character comparison.

In `@src/md/links.zig`:
- Around line 1-2: The parameter base_off on the function processLink (type
Parser) is unused and currently discarded; either remove base_off from
processLink's signature and update all call sites accordingly, or keep it but
document its intent and stop assigning it to _ (replace the discard with a
clarifying comment like "reserved for future offset handling") so readers know
it's intentionally unused; adjust any references to Parser.processLink to match
the new signature if you remove it.
- Around line 410-413: Replace the hardcoded 100-character check for wiki link
targets with a configurable limit: introduce a constant or parser field (e.g.,
WikiLinkMaxLen or Parser.wikiLinkMaxLen) and use that instead of the literal in
the validation block that checks target.len (the code containing "if (target.len
> 100)"). Ensure the new config has a sensible default of 100, propagate the
field into any functions that need it (or read the constant from the
parser/context where the link parsing function is declared), and update any
tests or callers to use the new configurable value.

In `@src/md/parser.zig`:
- Around line 52-54: The table_alignments buffer is only 64 entries but the
parser supports up to types.TABLE_MAXCOLCOUNT (128), which can cause OOB writes;
update the declaration of table_alignments to use types.TABLE_MAXCOLCOUNT (or
the TABLE_MAXCOLCOUNT constant) instead of the hardcoded 64, or alternatively
clamp uses of table_col_count/table indexing to the buffer length wherever code
references table_alignments; make the change around the table_alignments
declaration and any indexing sites that use table_col_count to ensure capacity
and bounds are consistent.
- Around line 223-235: The HtmlRenderer allocated by HtmlRenderer.init in
renderToHtml may leak because html_renderer.deinit() isn't guaranteed to run on
errors; add a defer html_renderer.deinit(); immediately after var html_renderer
= HtmlRenderer.init(allocator, input, tag_filter); (before initializing Parser
and definitely before any try calls) so the ArrayListUnmanaged inside
html_renderer is always freed on error or return, mirroring the existing defer
parser.deinit().

In `@src/md/ref_defs.zig`:
- Around line 284-300: Current code does an explicit loop over ref_defs.items to
check for an existing label then later may call lookupRefDef elsewhere, causing
redundant linear scans; replace the manual duplicate check with a single
lookupRefDef(self, norm_label) call and only proceed to allocator.dupe and
self.ref_defs.append(...) when lookupRefDef reports "not found" (or equivalent
false/err_not_found), thereby eliminating the extra iteration and centralizing
existence logic in lookupRefDef; keep the normalization value norm_label and use
it when appending .label to the new entry.
- Around line 9-48: normalizeLabel currently swallows allocation failures by
returning the original raw slice (using "catch return raw" at calls to
result.append and result.appendSlice), which leads to inconsistent behavior;
change normalizeLabel to propagate allocation errors instead: update its
signature to return an error union (e.g., ![]const u8 or []const
u8!AllocatorError), replace each "catch return raw" with "catch |err| return
err" (or propagate the allocator error), ensure you release any partially-built
ArrayListUnmanaged if needed before returning an error, and update all callers
of normalizeLabel (and any tests) to handle the new error-returning contract;
locate fixes around the normalizeLabel function and the result.append /
result.appendSlice calls as well as the UTF-8 handling using helpers.decodeUtf8,
helpers.encodeUtf8, and unicode.caseFold.
- Around line 51-59: lookupRefDef currently does linear scans over
self.ref_defs.items causing O(n²) behavior when called repeatedly (e.g., from
buildRefDefHashtable and link resolution); replace this with an O(1) hash lookup
by adding a hashtable field to Parser (or a std.HashMap instance) keyed by the
normalized label, update buildRefDefHashtable to normalize labels and populate
that map (instead of relying on repeated scans), and change lookupRefDef to
early-return via the map lookup (still validating empty/whitespace labels and
normalizing using normalizeLabel); reference functions/fields: lookupRefDef,
buildRefDefHashtable, normalizeLabel, and self.ref_defs.items to locate where to
add/replace logic.

In `@src/md/render_blocks.zig`:
- Around line 76-107: processTableRow currently skips over backtick code spans
(the '`' handling: bt_count, found_close, close_count logic) when scanning
row_text for '|' so pipes inside backticks are ignored; remove that
backtick-skip branch and let the main loop treat '`' like any other character
(keeping the existing backslash-escape handling that advances end by 2) so
unescaped '|' inside backtick spans will split cells per GFM-compat tests;
update any related comments and ensure variables
bt_count/close_count/found_close are removed or unused code cleaned up.

In `@src/transpiler.zig`:
- Around line 1358-1390: The catch on bun.md.renderToHtml currently drops the
renderer error; change the catch to capture the error (e.g., catch |err| ...)
and pass its message/details into transpiler.log.addErrorFmt so the log includes
the actual renderer error; update the transpiler.log.addErrorFmt call used in
the .md case (the block that constructs js_ast.Expr and returns ParseResult) to
include the captured err information in the formatted message while preserving
the existing context and return null behavior.

In `@test/js/bun/md/gfm-compat.test.ts`:
- Around line 19-25: The GFM renderer function renderGFM currently doesn't set
the tag_filter option, causing tagfilter-dependent tests to rely on defaults;
update the renderGFM options object to explicitly include tag_filter: true so
tag filtering is enabled (modify the renderGFM function where render(...) is
called and add the tag_filter option alongside tables, strikethrough, tasklists,
and permissive_autolinks).

In `@test/js/bun/md/md-spec.test.ts`:
- Around line 234-241: The loop over specFiles silently swallows parse errors by
using catch { continue; } which hides missing or invalid spec files; change the
catch to capture the error (e.g., catch (err)) and either rethrow a new Error
that includes the specPath and original error, or explicitly log a clear skip
reason before continuing so parseSpecFile failures are visible; update the block
around parseSpecFile(specPath) and the examples variable handling to include the
error variable and propagate or report it rather than silently continuing.

In `@test/js/bun/md/spec-permissive-autolinks.txt`:
- Around line 40-176: The spec prose contains several spelling mistakes that
need simple corrections: replace "formost" with "foremost" and all occurrences
of "alhanumerical" with "alphanumerical" (and any inconsistent uses), and fix
"Once again any"→"Once again, any" where missing commas for clarity; update
these words in the text blocks that include the phrases "First and formost",
"alhanumerical characters", and "alhanumerical" within the URL/path/query
descriptions to preserve examples and formatting.

In `@test/js/bun/md/spec-strikethrough.txt`:
- Around line 38-40: Fix the grammar in the explanatory sentence in
spec-strikethrough.txt: replace the incorrect word "then" with "they" so the
sentence reads "and similarly, they cannot close the span if they are preceded
with a whitespace." Locate the sentence in the file (the paragraph starting
"Also note the markers cannot open...") and update only that word to correct the
grammar.

In `@src/bun.js/api/MarkdownObject.zig`:
- Line 129: Remove the duplicated constant declaration BLOCK_FENCED_CODE from
the JsCallbackRenderer scope and replace all references to it with the canonical
md.types.BLOCK_FENCED_CODE; i.e., delete the local const BLOCK_FENCED_CODE =
0x10 in src/bun.js/api/MarkdownObject.zig and update uses inside the
JsCallbackRenderer struct and its methods to reference
md.types.BLOCK_FENCED_CODE (or import that symbol explicitly) so the flag value
remains authoritative from the md module.

In `@docs/runtime/markdown.mdx`:
- Around line 192-203: The example shows the same key name "strikethrough" used
both as a callback and as a parser option in the Bun.markdown.render call, which
is confusing; update the example to avoid the name collision by renaming the
callback (e.g., "strikethroughCallback") or the option in the sample object, or
add a short clarifying sentence after the snippet stating that callbacks and
parser options share a namespace and that the last key wins so you should use
either the callback OR the option, not both; reference the Bun.markdown.render
invocation and the "strikethrough" callback/option to locate the change.

In `@src/md/html_renderer.zig`:
- Around line 377-393: In HtmlRenderer.updateTagFilterRawDepth, remove the
redundant length check inside the opening-tag branch (the `content.len < 2` in
the self-closing detection) because the function already returned for
content.len < 2 at the top; update the condition that detects NOT self-closing
to only inspect the last two bytes (e.g., check that content[content.len - 2] !=
'/' or content[content.len - 1] != '>') so the self-closing detection is correct
and simpler.

In `@src/md/line_analysis.zig`:
- Around line 59-60: The function isOpeningCodeFence reads self.text[off]
without verifying off is within bounds; add a defensive bounds check at the
start of isOpeningCodeFence (e.g., ensure off < self.text.len()) and return a
non-fence result immediately if out of range, then proceed to access
self.text[off] and subsequent indices only after verifying their bounds;
reference the isOpeningCodeFence function, the off parameter, and self.text
accesses when implementing this guard.

In `@src/md/render_blocks.zig`:
- Around line 104-117: The current code returns immediately on allocation
failure for buf.ensureTotalCapacity causing cell content to be skipped; change
the error handling for ensureTotalCapacity so you either propagate the
allocation error to the caller (returning the error) or set a local fallback
flag and continue processing without unescaping pipes (using original
cell_content) instead of an early return; update the handling where
ensureTotalCapacity is called (the buf.ensureTotalCapacity(self.allocator,
cell_content.len) invocation) and ensure subsequent logic around buf,
appendAssumeCapacity, and defer buf.deinit(self.allocator) respects the chosen
error path.

In `@test/js/bun/md/gfm-compat.test.ts`:
- Around line 13-17: The module-level const md = Bun.markdown is being shadowed
by test callback parameters named md; rename one of them for clarity—e.g., keep
const md = Bun.markdown but rename the test parameter(s) from md to markdown or
inputMd, and update any references in those tests (tests that call render or
assert against the parameter) so there is no shadowing; alternatively rename the
module-level const to markdownRenderer and keep test parameters as-is, ensuring
all usages of render and Bun.markdown reference the renamed identifier.

In `@test/js/bun/md/md-spec.test.ts`:
- Around line 15-69: The parseSpecFile function fails on CRLF files because
split("\n") leaves trailing "\r" characters which break sentinel checks like
lines[i] === "."; fix by normalizing line endings before splitting (e.g.,
replace all "\r\n" or "\r" with "\n") or by trimming "\r" from each line when
reading content; update parseSpecFile (references: parseSpecFile, readFileSync,
the split("\n") call and the "." sentinel checks) to perform this normalization
so the "." and fence comparisons work on Windows.

In `@test/js/bun/md/spec-tables.txt`:
- Around line 231-232: The sentence in spec-tables.txt ("Contents of each cell
is parsed as an inline text which may contents any") has a typo — replace
"contents" with "contain" so it reads "Contents of each cell is parsed as an
inline text which may contain any", updating the documentation text accordingly.

In `@src/md/ref_defs.zig`:
- Around line 9-61: lookupRefDef currently leaks the temporary normalized label
returned by normalizeLabel and normalizeLabel can leak its partially-built
ArrayList on OOM; fix by making normalizeLabel ensure the ArrayList is
deinitialized on all early-return/error paths (deinit the ArrayList before
returning raw on OOM) and change lookupRefDef to capture the normalized result
into a variable and defer its deinitialization (call the corresponding
ArrayList/allocator cleanup) before iterating; reference normalizeLabel and
lookupRefDef and ensure every path that returns from normalizeLabel or
lookupRefDef cleans up allocator-backed buffers via defer.

In `@src/md/render_blocks.zig`:
- Line 95: The literal 64 in the table alignment logic should be extracted to a
named constant for clarity and reuse: define a constant like MAX_TABLE_COLUMNS
(e.g., in the types or a common constants module) and replace the magic number
in the expression that computes align_data (the line using cell_index < 64 and
self.table_alignments) with that constant; update any other places that rely on
the same limit (e.g., accesses of self.table_alignments) to use the new
MAX_TABLE_COLUMNS to ensure consistency.

In `@docs/runtime/markdown.mdx`:
- Around line 72-74: The description for Bun.markdown.render() incorrectly
implies it returns React elements; update the text for the
`Bun.markdown.render()` section to clarify that it concatenates string outputs
and returns a string—replace or remove the phrase "React elements" (suggested
replacement: "HTML/JSX strings" or simply "HTML strings") so the docs accurately
state the function returns a string.

In `@src/bun.js/api/MarkdownObject.zig`:
- Around line 84-90: The code returns error.JSError when
js_renderer.has_js_error is set but doesn't distinguish OOM from JS exceptions;
update the render-return paths (the block that checks js_renderer.has_js_error
and then calls js_renderer.getResult() / bun.String.createUTF8ForJS) to track
allocator OOM separately (e.g., set a separate flag when appendToTop/stack
append fails) and, before returning error.JSError, call throwOutOfMemory() if
that OOM flag is set; apply the same change to the other occurrences where
js_renderer.has_js_error is checked so any internal allocator failure triggers
throwOutOfMemory() rather than a plain error.JSError.

In `@src/md/blocks.zig`:
- Around line 770-839: The consumeRefDefsFromCurrentBlock function currently
swallows allocator failures (self.buffer.append(... ) catch {},
self.allocator.dupe(...) catch return, self.ref_defs.append(...) catch return)
which can lead to lost/misaligned data; change these to handle errors
explicitly: for buffer append failures (self.buffer.append and the second
appendSlice call) return an error or set a parser-level warning flag and stop
merging so parsing doesn't continue on a partially-built merged buffer; for
dupe/append failures (self.allocator.dupe for result.dest/result.title and
self.ref_defs.append) propagate the error (return) or record a non-fatal warning
and skip adding that single ref-def instead of silently continuing; update
callers of consumeRefDefsFromCurrentBlock or Parser to accept/observe the
returned error or flag so callers can log or handle allocation failures.

In `@src/md/inlines.zig`:
- Around line 24-46: The function processLeafBlock currently swallows allocator
failures via the catch {} on buffer.append and buffer.appendSlice which can
produce incomplete merged content; change processLeafBlock to propagate
allocation errors (e.g., return an error union like ?void or an error type)
instead of swallowing them, replace the catch {} with proper error propagation
from buffer.append and buffer.appendSlice, and update all callers to handle the
propagated error (including calls to processInlineContent) or alternatively
record a failure flag and early-return before calling processInlineContent;
reference the symbols processLeafBlock, buffer.append, buffer.appendSlice,
merged, and processInlineContent when making the changes.
- Around line 461-468: The append calls to self.emph_delims
(self.emph_delims.append(self.allocator, {...}) catch {}) silently ignore
allocation failures which drops delimiters and corrupts emphasis parsing;
replace the silent catch by handling the error—either propagate the allocator
error out of the surrounding function (use try/return err) or record a
persistent allocation-failure flag on the parser (e.g., self.alloc_failed =
true) and abort/skip further delimiter collection so callers can react; update
both occurrences (the append at run_start and the second append around lines
477-484) to use the chosen error-handling approach and ensure the caller checks
the propagated error or the failure flag.

In `@src/md/parser.zig`:
- Around line 5-62: The Parser struct exposes many internal fields (e.g.,
allocator, text, size, flags, renderer, image_nesting_level, link_nesting_level,
code_indent_offset, mark_char_map, marks, containers, block_bytes, buffer,
emph_delims, n_containers, current_block, current_block_lines, opener_stacks,
unresolved_link_head, table_cell_boundaries_head, html_block_type, fence_indent,
table_col_count, table_alignments, ref_defs,
last_line_has_list_loosening_effect, etc.); rename these fields to use the Zig
private-prefix (prepend `#` to each field name) and then update every usage
across the codebase (constructors/initializers, method implementations, tests,
and any module that referenced them) to the new `#`-prefixed names so the Parser
API remains public while its internal state is private. Ensure struct literals,
default values, and any pattern-matching or field access are updated
consistently and run the build to fix all references.

In `@test/js/bun/md/gfm-compat.test.ts`:
- Around line 354-356: Update the comment to reflect current behavior: replace
the outdated note about Bun needing a new tagfilter option with a statement that
renderGFM explicitly enables tag_filter, so the tests document GFM behavior with
tag_filter already enabled; reference renderGFM and the tag_filter option in the
updated comment near the existing NOTE block.

In `@bench/json5/json5.mjs`:
- Around line 12-57: The benchmark data is non-deterministic because
Math.random() is used in generateLargeJson5 and when building largeObject;
replace those Math.random() calls with a seeded PRNG so runs are reproducible:
add a small deterministic generator (e.g., mulberry32/xorshift) initialized with
a fixed seed and call it instead of Math.random() inside generateLargeJson5 (for
value and hex generation) and inside the largeObject Array.from mapping (for
value), ensuring hex formatting still uses the PRNG output and all places that
used Math.random() are switched to the seeded generator (refer to function
generateLargeJson5 and the largeObject constant).

In `@docs/runtime/file-types.mdx`:
- Line 8: The docs list of supported file extensions is missing `.md`, which is
misleading because the `.md` loader exists; update the extensions list in the
file-types overview by adding `.md` to the existing inline list (the string
containing `.js .cjs .mjs ... .sh`) so the markdown loader is documented
alongside the other extensions.

In `@packages/bun-types/bun.d.ts`:
- Around line 1149-1192: RenderCallbacks is missing handlers for parsed math and
underline spans, so when latexMath/underline are enabled render() silently drops
those nodes; add two callbacks to the RenderCallbacks interface—math (e.g.
math?: (children: string, meta?: MathMeta) => string | null | undefined) and
underline (e.g. underline?: (children: string) => string | null | undefined)—so
getSpanCallback()/render() can map those span types instead of returning .zero;
update types referenced (MathMeta) or reuse existing meta shapes as appropriate
and ensure RenderCallbacks includes these new symbols.

In `@src/api/schema.zig`:
- Around line 345-348: The C/C++ binding enum BunLoaderType in
headers-handwritten.h is missing several members and has numeric mismatches with
the Zig Loader enum in src/api/schema.zig; add constants for base64, dataurl,
text, bunsh, sqlite, sqlite_embedded, html, and json5 with the exact integer
values that match the Zig Loader sequence (fill in values 12–18 for the missing
ones and add json5 at its correct value), and update the md constant to use the
same numeric value as the Zig enum (ensure all BunLoaderType numeric assignments
mirror the Zig Loader order so there are no conflicts between md and json5).

In `@src/bun.js/bindings/napi.cpp`:
- Around line 2106-2109: The ArrayBuffer creation using
ArrayBuffer::createFromBytes with createSharedTask can throw, but the code does
not guard with NAPI_RETURN_IF_EXCEPTION(env), so if creation fails the shared
finalizer may run and call finalize_cb on caller-owned memory; immediately after
the ArrayBuffer::createFromBytes(...) call (the line constructing arrayBuffer)
add NAPI_RETURN_IF_EXCEPTION(env) to return on exception and prevent scheduling
the createSharedTask finalizer; reference symbols: ArrayBuffer::createFromBytes,
createSharedTask, finalize_cb, finalize_hint, env.

In `@src/interchange/yaml.zig`:
- Around line 404-408: The .stack_overflow branch in addToLog currently returns
error.StackOverflow without writing any diagnostic entries; modify the
.stack_overflow arm in pub fn addToLog(this: *const Error, source: *const
logger.Source, log: *logger.Log) to emit the same kind of diagnostic/log entry
used by other branches (e.g., unexpected_eof) before returning
error.StackOverflow so that temp_log is populated for the bundler path and
YAML.parse/SyntaxError fallback; locate the .stack_overflow case in addToLog and
add a call to the logger routines that produce the diagnostic (using the
provided source and log) prior to returning error.StackOverflow.

In `@src/md/helpers.zig`:
- Around line 447-460: trackText currently swallows allocation failures via
multiple "appendSlice(... ) catch {}" calls which can silently drop heading
text; change trackText (in HeadingIdTracker) to surface or handle OOMs instead
of ignoring them: either make trackText return an error (e.g., pub fn
trackText(...) !void) and replace each "appendSlice(... ) catch {}" with "try
self.text_buf.appendSlice(allocator, ...)" so allocation errors propagate, or
centrally handle the error (e.g., catch |err| { log the allocator error and set
self.in_heading = false } ) so you do not silently lose heading content; update
all sites calling trackText accordingly and include the same treatment for the
decodeEntityToUtf8 branch and references to self.text_buf.appendSlice.

In `@src/options.zig`:
- Around line 782-783: Update the invalid-loader error string passed to
global.throwInvalidArguments so it includes "json5" among the allowed loader
names; specifically modify the string currently returned (the one that lists
"js, jsx, tsx, ts, css, file, toml, yaml, wasm, bunsh, json, or md") to also
include "json5" (e.g., "... json5, or md") so users see the correct set of valid
loaders when the check in this code path triggers.

In `@test/js/bun/jsc-stress/fixtures/dfg-put-by-val-direct-with-edge-numbers.js`:
- Line 94: The inner for-loop reuses the outer-scope variable name `i`, which is
confusing and can trigger linters; change the loop variable in the inner loop
that iterates "for (var i = 0; i < testLoopCount; ++i)" to a distinct name such
as `j` (or another unused identifier) so the loop uses `for (var j = 0; j <
testLoopCount; ++j)` and update any references inside that loop body accordingly
(search for uses of `i` within the inner loop scope to rename).

In
`@test/js/bun/jsc-stress/fixtures/dfg-try-catch-wrong-value-recovery-on-ic-miss.js`:
- Around line 20-25: The object literal o2 defines a data property f: 500 and
immediately declares a getter get f() that overwrites it, making the 500 value
unreachable; either remove the redundant data property f: 500 from o2 or, if the
duplicate was intentional to shape the object for IC/stress testing, keep both
but add an inline comment next to o2 (or above it) explaining the intent (e.g.,
"data property present to force shape, then replaced by getter for IC recovery
tests") so future readers understand why f appears twice.

In `@test/js/bun/jsc-stress/fixtures/ftl-call-exception.js`:
- Around line 20-47: The code redeclares result with var and reassigns the
function-declared symbol bar; change the top-level function declaration bar to a
function expression assigned to a const (e.g., const bar = function(...) { ... }
or const bar = (..) => ... ) so it can be reassigned later, and replace both var
result declarations in the warm-up loop and after the throw with block-scoped
let (or const where appropriate) to avoid redeclaration errors; update
references to result and bar in foo(...) calls accordingly.

In `@test/js/bun/jsc-stress/fixtures/ftl-get-by-id-getter-exception.js`:
- Around line 21-28: The loop redeclares function-scoped vars (o, result) with
var each iteration which violates noRedeclare; fix by declaring these bindings
once and reusing them (e.g., move declaration of o and result outside the for
loop or switch to block-scoped let for o and result inside the loop) so that the
code using foo(o) and testLoopCount keeps the same behavior without var
redeclarations.

In `@test/js/bun/jsc-stress/fixtures/ftl-get-by-id-slow-exception.js`:
- Around line 21-25: The loop re-declares function-scoped vars (var o, var
result) causing noRedeclare lint failures; fix by declaring the bindings once
before the loop and reusing them inside (e.g., replace "var o; o = {…}; var
result = foo(o);" with a single pre-loop declaration like "let o, result;" or
"var o, result;" hoisted once and then assign within the loop), update the same
pattern in the other occurrence that mirrors lines 41-45, and ensure calls to
foo(o) still assign into the reused result variable.

In `@test/js/bun/jsc-stress/fixtures/ftl-string-equality.js`:
- Around line 9-13: The loops currently use "var i" which redeclares i in the
same scope; change each loop header that uses "var i" (e.g., the for loop
initializing array elements: for (var i = 0; ...), and the other loops later in
the file referenced at Lines 26 and 29) to use "let i" instead so each loop gets
a block-scoped iterator and avoids Biome noRedeclare errors.

In `@test/js/bun/jsc-stress/fixtures/ftl-try-catch-varargs-call-throws.js`:
- Around line 29-33: Add an explicit assertion that the final call to foo(f,
[10, 20, 30]) throws once flag is set so the exceptional path is actually
tested; locate the loop and final call where foo and the variable flag are used
(the block using testLoopCount and the subsequent flag = true; foo(...) call)
and wrap or replace the final invocation with an assertion that expects an
exception from foo(f, [10,20,30]) to ensure the flagged exception path is
exercised.

In `@test/js/bun/jsc-stress/fixtures/wasm/bbq-osr-with-exceptions.js`:
- Around line 29-35: The catch block around the loop that calls
fn2(global1.value, global11.value, fn3) currently swallows all exceptions;
change it so only RangeError is handled silently and any other exception is
rethrown (or otherwise propagated). Locate the try/catch that wraps the for-loop
calling fn2 and update the catch to check e instanceof RangeError and rethrow e
when it is not a RangeError.

In `@test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try4.js`:
- Around line 33-36: The test fixture uses a high-precision float literal in fn2
(8.433544074882645e1) that will lose precision at runtime; open the fn2 function
and replace the scientific notation literal with a runtime-stable value (e.g.,
84.33544074882646 or a shortened 84.33544) so the stored test data matches the
value produced at runtime and avoids misleading precision differences.

In `@test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try5.js`:
- Around line 2-9: Normalize inconsistent indentation around the helper setup:
adjust the indentation of the instantiate function body and the subsequent
declarations (instantiate, bytes, report, isJIT, extra, and the async IIFE) so
they match the file's prevailing style (make the function body and inner lines
use the same indentation as the surrounding top-level declarations) to keep
formatting consistent.
- Around line 1-12: Add the same skip-mode directives used in the other variants
to this test so it will be skipped when JIT is disabled: insert the two lines
that push "wasm-no-jit" and "wasm-no-wasm-jit" into $skipModes near the top of
the file (above or just before the instantiate function) so the test with
symbols like instantiate, callerIsBBQOrOMGCompiled, and extra={isJIT} will be
skipped in non-JIT runs.

In `@test/js/bun/jsc-stress/fixtures/wasm/omg-recompile-from-two-bbq.js`:
- Around line 27-34: The try/catch and promise handlers currently swallow errors
and provide no progress reporting; update the catch block that wraps the loop
invoking fn0(fn1) to call report('error', e) (or report('error') plus logging
the exception) instead of being empty, and add a .then(() => report('after'))
and a terminal .catch(e => report('error', e)) on the immediately-invoked async
call so both success and failure are reported; refer to the symbols fn0, fn1,
report and the IIFE promise tail in the diff when making the changes.
- Around line 25-26: The JSDoc type annotation for the destructured exports is
incomplete—replace the truncated comment around (i0.instance.exports) with a
full `@type` block so IDEs recognize types; update the comment that surrounds the
destructuring of fn0, fn1, global5..global8, table3..table13, tag0..tag3 to
start with /** `@type` {{ ... }} */ and list the exported symbols (fn0, fn1,
global5, global6, global7, global8, table3, table4, table5, table6, table7,
table8, table9, table10, table11, table12, table13, tag0, tag1, tag2, tag3} so
the annotation is well-formed and not truncated, leaving the destructuring
assignment (i0.instance.exports) unchanged.

In `@test/js/bun/json5/generate_json5_test_suite.ts`:
- Around line 54-56: The hardcoded relative module path in json5PkgPath is
fragile; update the loader for JSON5 so it first attempts to require('json5')
normally and if that fails uses a robust resolve via require.resolve with
explicit search paths (e.g., process.cwd() or a repo-root 'bench/json5' path) to
locate the package, then assign the resolved path to json5PkgPath and load JSON5
into JSON5Ref; change references in generate_json5_test_suite.ts (json5PkgPath,
JSON5Ref) to use this try/catch + require.resolve fallback instead of the fixed
"../../../../bench/json5/node_modules/json5" string.

In `@test/js/bun/json5/json5.test.ts`:
- Around line 1183-1186: In the "deeply nested arrays" test replace use of
String.prototype.repeat for building the input with Buffer.alloc to follow repo
guidelines: instead of "[".repeat(depth) + "1" + "]".repeat(depth) construct the
opening and closing repeated segments using Buffer.alloc(depth, "[").toString()
and Buffer.alloc(depth, "]").toString() (keep the variables depth, input and
expected as-is) so the test builds the same nested string without using
.repeat().